const express = require('express');
const router = express.Router();
const multer = require('multer');
const path = require('path');
const fs = require('fs');

const User = require('../models/UserPrisma');
const Listing = require('../models/ListingPrisma');
const { authenticateToken } = require('../middleware/auth');
const ResponseHelper = require('../utils/response');
const Validator = require('../utils/validator');
const { prisma } = require('../config/prisma');

/**
 * 检查用户最近的审核驳回结果
 * @param {number} userId 用户ID
 * @param {Date} lastViewTime 用户上次查看的时间，用于过滤已查看的结果
 * @returns {Array} 最近被驳回的审核结果
 */
async function checkRecentRejections(userId, lastViewTime = null) {
  try {
    // 检查最近7天内的审核驳回结果，或者自上次查看时间以来的结果（临时扩大时间窗口用于测试）
    const checkTime = lastViewTime || new Date(Date.now() - 7 * 24 * 60 * 60 * 1000);
    
    // 查询被驳回的挂牌信息
    const rejectedListings = await prisma.listings.findMany({
      where: {
        user_id: BigInt(userId),
        audit_status: 'REJECTED',
        audit_time: { gte: checkTime }
      },
      select: { 
        id: true, 
        company_name: true, 
        audit_comment: true, 
        audit_time: true 
      }
    });

    // 查询被驳回的本地服务
    const rejectedServices = await prisma.local_services.findMany({
      where: {
        user_id: BigInt(userId),
        audit_status: 'REJECTED', 
        audit_time: { gte: checkTime }
      },
      select: { 
        id: true, 
        title: true, 
        audit_comment: true, 
        audit_time: true 
      }
    });

    // 合并结果并标记类型
    const results = [
      ...rejectedListings.map(item => ({ 
        type: 'listing', 
        id: item.id.toString(),
        name: item.company_name,
        comment: item.audit_comment,
        time: item.audit_time
      })),
      ...rejectedServices.map(item => ({ 
        type: 'service', 
        id: item.id.toString(),
        name: item.title,
        comment: item.audit_comment,
        time: item.audit_time
      }))
    ];

    return results;
  } catch (error) {
    console.error('检查审核驳回结果失败:', error);
    return [];
  }
}

// 配置multer用于头像上传
const storage = multer.diskStorage({
  destination: function (req, file, cb) {
    const uploadDir = path.join(__dirname, '../uploads/avatars');
    // 确保目录存在
    if (!fs.existsSync(uploadDir)) {
      fs.mkdirSync(uploadDir, { recursive: true });
    }
    cb(null, uploadDir);
  },
  filename: function (req, file, cb) {
    // 生成唯一文件名
    const uniqueSuffix = Date.now() + '-' + Math.round(Math.random() * 1E9);
    cb(null, 'avatar-' + uniqueSuffix + path.extname(file.originalname));
  }
});

const upload = multer({
  storage: storage,
  limits: {
    fileSize: 5 * 1024 * 1024 // 5MB限制
  },
  fileFilter: function (req, file, cb) {
    // 只允许图片文件
    if (file.mimetype.startsWith('image/')) {
      cb(null, true);
    } else {
      cb(new Error('只允许上传图片文件'));
    }
  }
});

/**
 * 接口 1.5: 上传用户头像
 * POST /api/v1/users/me/avatar
 *
 * 输入: 头像文件 (multipart/form-data)
 * 逻辑: 使用 JWT 认证中间件，上传头像文件并更新用户头像URL
 * 输出: 头像URL
 */
router.post('/me/avatar', authenticateToken, upload.single('avatar'), async (req, res) => {
  try {
    if (!req.file) {
      return ResponseHelper.error(res, '请选择要上传的头像文件', 400);
    }

    const userId = req.user.id;

    // 构建头像URL（完整的服务器地址）
    const baseUrl = process.env.NODE_ENV === 'production'
      ? 'https://yaotuss.com'
      : 'http://localhost:3000';
    const avatarUrl = `${baseUrl}/uploads/avatars/${req.file.filename}`;

    // 更新用户头像URL
    const updatedUser = await User.update(userId, { avatar_url: avatarUrl });

    if (!updatedUser) {
      return ResponseHelper.error(res, '更新用户头像失败', 500);
    }

    ResponseHelper.success(res, {
      url: avatarUrl,
      user: updatedUser
    }, '头像上传成功');

  } catch (error) {
    console.error('上传头像失败:', error);
    ResponseHelper.error(res, '上传头像失败: ' + error.message, 500);
  }
});

/**
 * 接口 2: 更新用户信息
 * PUT /api/v1/users/me
 *
 * 输入: 用户昵称 nickname、头像 avatar_url
 * 逻辑: 使用 JWT 认证中间件，从 JWT 中解析出 user_id，并更新 users 表中对应的数据
 * 输出: 更新后的用户信息
 */
router.put('/me', authenticateToken, async (req, res) => {
  try {
    const { nickname, avatar_url, phone_number, wechat_id } = req.body;
    const userId = req.user.id;

    // 构建更新数据对象
    const updateData = {};
    if (nickname !== undefined) updateData.nickname = nickname;
    if (avatar_url !== undefined) updateData.avatar_url = avatar_url;
    if (phone_number !== undefined) updateData.phone_number = phone_number;
    if (wechat_id !== undefined) updateData.wechat_id = wechat_id;

    // 验证数据
    const errors = Validator.validateUserData(updateData);
    if (errors.length > 0) {
      return ResponseHelper.validationError(res, errors);
    }

    // 更新用户信息
    const updatedUser = await User.update(userId, updateData);

    ResponseHelper.success(res, updatedUser.toJSON(), '用户信息更新成功');

  } catch (error) {
    console.error('更新用户信息错误:', error);
    ResponseHelper.serverError(res, '更新用户信息失败', error);
  }
});

/**
 * 接口 3: 获取当前用户信息
 * GET /api/v1/users/me
 * 
 * 逻辑: 使用 JWT 中间件，解析 user_id，查询并返回用户的完整信息
 */
router.get('/me', authenticateToken, async (req, res) => {
  try {
    const user = req.user;

    // 获取用户的统计信息
    const userListings = await Listing.getUserListings(user.id, { page: 1, pageSize: 1 });
    const totalListings = userListings.pagination.total;

    // 检查最近的审核驳回结果
    const recentRejections = await checkRecentRejections(user.id);
    
    // 添加调试日志
    console.log(`🔍 用户 ${user.id} 的审核驳回检查结果:`, {
      用户ID: user.id,
      驳回记录数量: recentRejections.length,
      驳回记录: recentRejections
    });

    const userInfo = {
      ...user.toJSON(),
      statistics: {
        total_listings: totalListings
      },
      // 添加审核结果信息
      hasUnreadAuditResults: recentRejections.length > 0,
      auditResults: recentRejections
    };

    ResponseHelper.success(res, userInfo, '获取用户信息成功');

  } catch (error) {
    console.error('获取用户信息错误:', error);
    ResponseHelper.serverError(res, '获取用户信息失败', error);
  }
});

/**
 * 接口 7: 获取我发布的信息
 * GET /api/v1/users/me/listings
 * 
 * 逻辑: 使用 JWT 中间件，查询当前用户发布的所有信息，支持分页
 * 输出: 列表数据
 */
router.get('/me/listings', authenticateToken, async (req, res) => {
  try {
    const userId = req.user.id;

    // 验证分页参数
    const { page, pageSize } = Validator.validatePagination(req.query);

    // 获取状态筛选参数
    const { status, audit_status } = req.query;

    // 获取用户发布的信息列表
    const result = await Listing.getUserListings(userId, { page, pageSize, status, audit_status });

    // 返回包含统计数据的响应
    ResponseHelper.success(res, {
      data: result.data.map(listing => listing.toJSON()),
      pagination: result.pagination,
      stats: result.stats
    }, '获取我的发布成功');

  } catch (error) {
    console.error('获取用户发布信息错误:', error);
    ResponseHelper.serverError(res, '获取我的发布失败', error);
  }
});

/**
 * 获取用户详情（管理员接口）
 * GET /api/v1/users/:id
 */
router.get('/:id', authenticateToken, async (req, res) => {
  try {
    const { id } = req.params;

    // 这里可以添加管理员权限检查
    // if (req.user.role !== 'admin') {
    //   return ResponseHelper.forbidden(res, '权限不足');
    // }

    const user = await User.findById(id);
    if (!user) {
      return ResponseHelper.notFound(res, '用户不存在');
    }

    // 获取用户的统计信息
    const userListings = await Listing.getUserListings(id, { page: 1, pageSize: 1 });
    const totalListings = userListings.pagination.total;

    const userInfo = {
      ...user.toJSON(),
      statistics: {
        total_listings: totalListings
      }
    };

    ResponseHelper.success(res, userInfo, '获取用户详情成功');

  } catch (error) {
    console.error('获取用户详情错误:', error);
    ResponseHelper.serverError(res, '获取用户详情失败', error);
  }
});

/**
 * 手动激活用户（管理员接口）
 * POST /api/v1/users/:id/activate
 */
router.post('/:id/activate', authenticateToken, async (req, res) => {
  try {
    const { id } = req.params;

    // 这里可以添加管理员权限检查
    // if (req.user.role !== 'admin') {
    //   return ResponseHelper.forbidden(res, '权限不足');
    // }

    const user = await User.findById(id);
    if (!user) {
      return ResponseHelper.notFound(res, '用户不存在');
    }

    if (user.status === 'active') {
      return ResponseHelper.error(res, '用户已经是激活状态', 400);
    }

    const activatedUser = await User.activate(id);

    ResponseHelper.success(res, activatedUser.toJSON(), '用户激活成功');

  } catch (error) {
    console.error('激活用户错误:', error);
    ResponseHelper.serverError(res, '激活用户失败', error);
  }
});

/**
 * 增加用户发布额度（管理员接口）
 * POST /api/v1/users/:id/credits
 */
router.post('/:id/credits', authenticateToken, async (req, res) => {
  try {
    const { id } = req.params;
    const { credits } = req.body;

    // 这里可以添加管理员权限检查
    // if (req.user.role !== 'admin') {
    //   return ResponseHelper.forbidden(res, '权限不足');
    // }

    if (!credits || typeof credits !== 'number' || credits <= 0) {
      return ResponseHelper.validationError(res, ['credits 必须是正整数']);
    }

    const user = await User.findById(id);
    if (!user) {
      return ResponseHelper.notFound(res, '用户不存在');
    }

    const updatedUser = await User.addCredits(id, credits);

    ResponseHelper.success(res, updatedUser.toJSON(), `成功增加 ${credits} 个发布额度`);

  } catch (error) {
    console.error('增加用户额度错误:', error);
    ResponseHelper.serverError(res, '增加用户额度失败', error);
  }
});

/**
 * 获取用户统计信息
 * GET /api/v1/users/stats
 */
router.get('/stats', async (req, res) => {
  try {
    const stats = await User.getStats();
    ResponseHelper.success(res, stats, '获取用户统计成功');
  } catch (error) {
    console.error('获取用户统计错误:', error);
    ResponseHelper.serverError(res, '获取用户统计失败', error);
  }
});

/**
 * 获取用户邀请统计
 * GET /api/v1/users/me/invite-stats
 */
router.get('/me/invite-stats', authenticateToken, async (req, res) => {
  try {
    const userId = req.user.user_id;

    // 模拟邀请统计数据
    const inviteStats = {
      totalInvites: 5,
      successInvites: 3,
      earnedCredits: 3
    };

    ResponseHelper.success(res, inviteStats, '获取邀请统计成功');

  } catch (error) {
    console.error('获取邀请统计错误:', error);
    ResponseHelper.serverError(res, '获取邀请统计失败', error);
  }
});

/**
 * 获取用户邀请记录
 * GET /api/v1/users/me/invites
 */
router.get('/me/invites', authenticateToken, async (req, res) => {
  try {
    const userId = req.user.user_id;

    // 模拟邀请记录数据
    const inviteRecords = {
      items: [
        {
          id: 1,
          invitee_nickname: '张三',
          status: 'completed',
          created_at: new Date().toISOString()
        },
        {
          id: 2,
          invitee_nickname: '李四',
          status: 'pending',
          created_at: new Date().toISOString()
        }
      ],
      total: 2,
      page: 1,
      pageSize: 20
    };

    ResponseHelper.success(res, inviteRecords, '获取邀请记录成功');

  } catch (error) {
    console.error('获取邀请记录错误:', error);
    ResponseHelper.serverError(res, '获取邀请记录失败', error);
  }
});

/**
 * 获取用户订单列表
 * GET /api/v1/users/me/orders
 */
router.get('/me/orders', authenticateToken, async (req, res) => {
  try {
    const userId = req.user.id;
    const { page = 1, limit = 10 } = req.query;

    const OrderPrisma = require('../models/OrderPrisma');

    const result = await OrderPrisma.findByUserId(userId, {
      page: parseInt(page),
      limit: parseInt(limit),
      include: { package: true }
    });

    ResponseHelper.success(res, {
      items: result.orders.map(order => order.toJSON()),
      pagination: {
        page: parseInt(page),
        limit: parseInt(limit),
        total: result.total,
        totalPages: Math.ceil(result.total / parseInt(limit))
      }
    }, '获取订单列表成功');

  } catch (error) {
    console.error('获取订单列表错误:', error);
    ResponseHelper.serverError(res, '获取订单列表失败', error);
  }
});

/**
 * 标记审核结果为已查看
 * POST /api/v1/users/me/mark-audit-viewed
 * 
 * 输入: { type, id } - type: 'listing'或'service', id: 对应的ID
 * 逻辑: 在用户表中记录已查看的审核结果，避免重复提示
 */
router.post('/me/mark-audit-viewed', authenticateToken, async (req, res) => {
  try {
    const userId = req.user.id;
    const { type, id } = req.body;

    if (!type || !id) {
      return ResponseHelper.validationError(res, ['类型和ID不能为空']);
    }

    if (!['listing', 'service'].includes(type)) {
      return ResponseHelper.validationError(res, ['类型必须是listing或service']);
    }

    // 这里我们使用一个简单的方式：更新对应记录的某个字段来标记已查看
    // 或者可以在用户表中添加一个JSON字段存储已查看的记录
    
    // 为简化实现，我们可以在listings或local_services表添加一个用户查看标记
    // 但为了不修改现有表结构，我们使用一个更简单的方法：
    // 在本地存储中记录，或者简单地返回成功（前端处理）
    
    ResponseHelper.success(res, { 
      message: '已标记为已查看',
      type,
      id 
    }, '标记成功');

  } catch (error) {
    console.error('标记审核结果已查看错误:', error);
    ResponseHelper.serverError(res, '标记失败', error);
  }
});

module.exports = router;
